//#include <stdio.h>
// 
//#include <limits.h>
//#include<time.h>
// 
//#include <math.h>
// 
//#define boolean int
// 
//#define false 0
// 
//#define true 1
// 
//#define MaxNode 50
// 
//#define EDGE_MAX 99
// 
//#define min(x,y) ((x>y)?y:x)
// 
// //////////////// 
// 
// // class Mode // 
// 
// //////////////// 
// 
//struct {
// 
//int run;
// 
//int edit;
// 
//int move;
// 
//int addnode;
// 
//int delnode;
// 
//int addedge;
// 
//int deledge;
// 
//int capacity;
// 
//} Mode;
// 
// //////////////// 
// 
// // class Color // 
// 
// //////////////// 
// 
//struct {
// 
//int black;
// 
//int cyan;
// 
//int red;
// 
//int pink;
// 
//int magenta;
// 
//int orange;
// 
//int blue;
// 
//} Color;
// //////////////// 
// 
// // class Node // 
// 
// //////////////// 
// 
//class Node {
// 
//friend FF;
// 
//boolean selected;
// 
//boolean mark;
// 
//Node() {
// 
//selected=false;
// 
//mark=false;
// 
//};
// 
//};
// 
// //////////////// 
// 
// // class Edge // 
// 
// //////////////// 
// 
//class Edge {
// 
//public:
// 
//friend FF;
// 
//int capacity;
// 
//boolean selected;
// 
//int min, max;
// 
//int flow;
// 
//boolean mark;
// 
//boolean exist() {
// 
//return (capacity > 0);
// 
//}
// 
//Edge(){
// 
//capacity = 0;
// 
//selected = false;
// 
//min=1;max=EDGE_MAX;
// 
//flow=0;
// 
//mark=false;
// 
//}
// 
//void set(int newcap) {
// 
//if ((newcap > max) || (newcap < min)) {
// 
//printf("Capacity out of range");
// 
//capacity = 1;
// 
//} else capacity = newcap;
// 
//if (flow > capacity) flow = capacity;
//
// 
//};
// 
// ////////////// 
// 
// // class FF // 
// 
// ////////////// 
// 
//class FF {
// 
//public:
// 
//int nnodes;
// 
//Node *nodes[MaxNode];
// 
//int source, sink, maxflow;
// 
//Edge *edges[MaxNode][MaxNode];
// 
//int mode;
// 
//int edit;
// 
//void reset();
// 
//int addNode() {
// 
//if (nnodes >= MaxNode -1) return -1;
// 
//Node *n = new Node();
// 
//nnodes++;
// 
//nodes[nnodes] = n;
// 
//sink = nnodes;
// 
//return nnodes;
// 
//};
// 
//void addEdge(int from, int to, int cap) {
// 
//edges[from][to]->set(cap);
// 
//}
// 
//FF();
// 
//int FF::FordFulkerson(int thesink, int u, int mont);
// 
//void initFlow();
// 
//void removeEdgeMarks();
// 
//void flowMax_go(int thesource, int thesink);
// 
//void display();
// 
//};
// 
//FF::FF() {
//nnodes=0; source = 1; sink = 2; maxflow=0;mode = Mode.edit;edit =Mode.move;
// 
//int i, j;
// 
//for (i=1;i<MaxNode;i++)
// 
//for (j=1;j<MaxNode;j++)
// 
//edges[i][j] = new Edge();
// 
//};
// 
//void FF::reset() {
// 
//int i, j;
// 
//for (i=1;i<MaxNode;i++)
// 
//for (j=1;j<MaxNode;j++) {
// 
//edges[i][j]->capacity=0;
// 
//edges[i][j]->selected=false;
// 
//edges[i][j]->flow=0;
// 
//edges[i][j]->mark=false;
// 
//}
// 
//nnodes=0;
// 
//};
// 
//int FF::FordFulkerson(int thesink, int u, int mont) {
// 
//int v;
// 
//int res=0;
// 
//Edge *e;
// 
//if (u==thesink) return mont;
// 
//nodes[u]->mark = true;
// 
//for (v=1; v<=nnodes && res==0; v++)
// 
//if (!nodes[v]->mark) {
// 
//e = edges[u][v];
// 
//if (e->exist() && (e->flow < e->capacity)) {
// 
//res = FordFulkerson(thesink, v, min(mont, e->capacity - e->flow));
// 
//if (res>0) {
// 
//e->mark = true;
// 
//e->flow +=res;
// 
//}
// 
//}
// 
//e = edges[v][u];
// 
//if (res==0 && e->exist() && e->flow > 0) {
// 
//res = FordFulkerson(thesink, v,min(mont, e->flow));
// 
//if (res>0) {
// 
//e->mark = true;
// 
//e->flow -=res;
// 
//}
// 
//}
//}
// 
//nodes[u]->mark = false;
// 
//return res;
// 
//};
// 
//void FF::initFlow() {
// 
//maxflow=0;
// 
//for (int i = 1; i<= nnodes; i++)
// 
//for (int j = 1; j <= nnodes; j++)
// 
//edges[i][j]->flow = 0;
// 
//};
// 
//void FF::removeEdgeMarks(){
// 
//for (int i = 1; i<= nnodes; i++)
// 
//for (int j = 1; j <= nnodes; j++)
// 
//edges[i][j]->mark = false;
// 
//};
// 
//void FF::flowMax_go(int thesource, int thesink) {
// 
//int flow1 = 1;
// 
//if (mode==Mode.edit) mode = Mode.run;
// 
//removeEdgeMarks();
// 
//maxflow=0;
// 
//while (flow1!=0) {
// 
//flow1=FordFulkerson(thesink, thesource, EDGE_MAX);
// 
//maxflow+=flow1;
// 
//};
// 
//};
// 
//void FF::display(){
// 
//for (int i=1;i<=nnodes;i++){
// 
//for (int k=1;k<=nnodes;k++) printf("%d/%d ",edges[i][k]->flow,edges[i][k]->capacity);
// 
//printf("\n");
// 
//};
// 
//printf("\n");
// 
//};
// 
// ////////// 
// 
// // Demo // 
// 
// ////////// 
// 
//class Demo{
// 
//public:
// 
//Demo();
// 
//};
//void Demo::Demo(){
// 
//FF myGraph;
// 
//myGraph.addNode();
// 
//myGraph.addNode();
// 
//myGraph.addNode();
// 
//myGraph.addNode();
// 
//myGraph.addNode();
// 
//myGraph.addNode();
// 
//myGraph.addEdge(1,2,3);
// 
//myGraph.addEdge(1,3,3);
// 
//myGraph.addEdge(2,4,2);
// 
//myGraph.addEdge(3,4,2);
// 
//myGraph.addEdge(2,3,1);
// 
//myGraph.addEdge(5,2,1);
// 
//myGraph.addEdge(3,5,1);
// 
//myGraph.addEdge(5,4,1);
// 
//myGraph.addEdge(5,6,3);
// 
//myGraph.addEdge(4,6,4);
// 
//myGraph.source=1;
// 
//myGraph.sink=6;
// 
//myGraph.initFlow();
// 
//myGraph.flowMax_go(myGraph.source, myGraph.sink);
// 
//myGraph.display();
// 
//};
// 
//void main(){
// 
//Demo demo;
// 
//};
//}